home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / game / think / AmiChess.lha / AmiChess / src / eval.c < prev    next >
C/C++ Source or Header  |  2002-10-31  |  22KB  |  847 lines

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include "common.h"
  5. #include "eval.h"
  6.  
  7. BitBoard passed[2];
  8. BitBoard weaked[2];
  9.  
  10. static short PawnSq[2][64]={
  11. {
  12. 0,0,0,0,0,0,0,0,
  13. 5,5,5,-10,-10,5,5,5,
  14. -2,-2,-2,6,6,-2,-2,-2,
  15. 0,0,0,25,25,0,0,0,
  16. 2,2,12,16,16,12,2,2,
  17. 4,8,12,16,16,12,4,4,
  18. 4,8,12,16,16,12,4,4,
  19. 0,0,0,0,0,0,0,0},
  20. {
  21. 0,0,0,0,0,0,0,0,
  22. 4,8,12,16,16,12,4,4,
  23. 4,8,12,16,16,12,4,4,
  24. 2,2,12,16,16,12,2,2,
  25. 0,0,0,25,25,0,0,0,
  26. -2,-2,-2,6,6,-2,-2,-2,
  27. 5,5,5,-10,-10,5,5,5,
  28. 0,0,0,0,0,0,0,0}
  29. };
  30.  
  31. static const short Passed[2][8] ={ { 0,48,48,96,144,192,240,0},{0,240,192,144,96,48,48,0} };
  32.  
  33. static const short isolani_normal[8]={-8,-10,-12,-14,-14,-12,-10,-8};
  34. static const short isolani_weaker[8]={-22,-24,-26,-28,-28,-26,-24,-22 };
  35.  
  36. static const short rank7[2]={ 6,1 };
  37. static const short rank8[2]={ 7,0 };
  38. static const BitBoard d2e2[2]={ 0x0018000000000000ULL,0x0000000000001800ULL };
  39. static const BitBoard brank7[2]={ 0x000000000000FF00ULL,0x00FF000000000000ULL };
  40. static const BitBoard brank8[2] ={ 0x00000000000000FFULL,0xFF00000000000000ULL };
  41. static const BitBoard brank67[2]={ 0x0000000000FFFF00ULL,0x00FFFF0000000000ULL };
  42. static const BitBoard brank58[2]={ 0x00000000FFFFFFFFULL,0xFFFFFFFF00000000ULL };
  43.  
  44. int ScoreP(short side)
  45. {
  46. short s,sq,i,i1,xside;
  47. short n1,n2,backward;
  48. short nfile[8];
  49. short EnemyKing;
  50. BitBoard c,t,p,blocker,*e;
  51. PawnSlot *ptable;
  52. if(board.b[side][pawn]==NULLBITBOARD) return 0;
  53. xside=1^side;
  54. EnemyKing=board.king[xside];
  55. p=board.b[xside][pawn];
  56. t=board.b[side][pawn];
  57. c=t;
  58. ptable=PawnTab[side];
  59. ptable+=PawnHashKey&PHashMask;
  60. TotalPawnHashCnt++;
  61. if(ptable->phase==phase&&ptable->pkey==KEY(PawnHashKey))
  62.     {
  63.     GoodPawnHashCnt++;
  64.     s=ptable->score;
  65.     passed[side]=ptable->passed;
  66.     weaked[side]=ptable->weaked;
  67.     goto phase2; 
  68.     }
  69. s=0;
  70. passed[side]=NULLBITBOARD;
  71. weaked[side]=NULLBITBOARD;
  72. memset(nfile,0,sizeof(nfile));
  73. while(t)
  74.     {
  75.     sq=leadz(t);
  76.     CLEARBIT(t,sq);
  77.     s+=PawnSq[side][sq]; 
  78.     if((p&PassedPawnMask[side][sq])==NULLBITBOARD)
  79.         {
  80.         if((side==white&&(FromToRay[sq][sq|56]&c)==0)||(side==black&&(FromToRay[sq][sq&7]&c)==0))
  81.             {
  82.             passed[side]|=BitPosArray[sq];
  83.             if(side==white) s+=(Passed[side][RANK(sq)]*phase)/12;
  84.             else if(side==black) s+=(Passed[side][RANK(sq)]*phase)/12;
  85.             }
  86.         }
  87.     backward=false;
  88.     if(side==white) i=sq+8;
  89.     else i=sq-8;
  90.     if(!(PassedPawnMask[xside][i]&~FileBit[ROW(sq)]&c)&&cboard[i]!=pawn)
  91.         {
  92.         n1=nbits(c&MoveArray[ptype[xside]][i]);
  93.         n2=nbits(p&MoveArray[ptype[side]][i]);
  94.         if(n1<n2) backward=true;
  95.         }
  96.     if(!backward&&(BitPosArray[sq]&brank7[xside]))
  97.         {
  98.         i1=1;
  99.         i+=(side==white?8:-8);
  100.         if(!(PassedPawnMask[xside][i]&~FileBit[ROW(i1)]&c))
  101.             {
  102.             n1=nbits(c&MoveArray[ptype[xside]][i]);
  103.             n2=nbits(p&MoveArray[ptype[side]][i]);
  104.             if(n1<n2) backward=true;
  105.             }
  106.         }
  107.     if(backward)
  108.         {
  109.         weaked[side]|=BitPosArray[sq];
  110.         s+=BACKWARDPAWN;
  111.         }
  112.     if((MoveArray[ptype[side]][sq]&p)&&(MoveArray[ptype[side]][sq]&c)) s+=PAWNBASEATAK;
  113.     nfile[ROW(sq)]++;
  114.     }
  115. for(i=0;i<=7;i++)
  116.     {
  117.     if(nfile[i]>1) s+=DOUBLEDPAWN;
  118.     if(nfile[i]&&(!(c&IsolaniMask[i])))
  119.         {
  120.         if(!(FileBit[i]&board.b[xside][pawn])) s+=isolani_weaker[i]*nfile[i];
  121.         else s+=isolani_normal[i]*nfile[i];
  122.         weaked[side]|=(c&FileBit[i]);
  123.         }
  124.     }
  125. if(computerplays==side)
  126.     {
  127.     if(nbits(board.b[computerplays][pawn])==8) s+=EIGHT_PAWNS;
  128.     if(nbits(stonewall[xside]&board.b[xside][pawn])==3) s+=STONEWALL;
  129.     n=0;
  130.     if(side==white) n=nbits((c>>8)&board.b[xside][pawn]&(rings[0]|rings[1]|rings[2]));
  131.     else n=nbits((c<<8)&board.b[xside][pawn]&(rings[0]|rings[1]|rings[2]));
  132.     if(n>1) s+=n*LOCKEDPAWNS;
  133.     }
  134. ptable->pkey=KEY(PawnHashKey);
  135. ptable->passed=passed[side];
  136. ptable->weaked=weaked[side];
  137. ptable->score=s;
  138. ptable->phase=phase;
  139.  
  140. phase2:
  141. c=board.b[side][pawn];
  142. sq=board.king[xside];
  143. if(side==white&&board.b[side][queen]&&(BitPosArray[C6]|BitPosArray[F6])&c)
  144.     {
  145.     if(c&BitPosArray[F6]&&sq>H6&&distance[sq][G7]==1) s+=PAWNNEARKING;
  146.     if(c&BitPosArray[C6]&&sq>H6&&distance[sq][B7]==1) s+=PAWNNEARKING;
  147.     }
  148. else if(side==black&&board.b[side][queen]&&(BitPosArray[C3]|BitPosArray[F3])&c)
  149.     {
  150.     if(c&BitPosArray[F3]&&sq<A3&&distance[sq][G2]==1) s+=PAWNNEARKING;
  151.     if(c&BitPosArray[C3]&&sq<A3&&distance[sq][B2]==1) s+=PAWNNEARKING;
  152.     }
  153. t=passed[side]&brank67[side];
  154. if(t&&(board.pmaterial[xside]==ValueR||(board.pmaterial[xside]==ValueN&&pieces[xside]==board.b[xside][knight])))
  155.     {
  156.     n1=ROW(board.king[xside]);
  157.     n2=RANK(board.king[xside]);
  158.     for(i=0;i<=6;i++)
  159.         {
  160.         if(t&FileBit[i]&&t&FileBit[i+1]&&(n1<i-1||n1>i+1||(side==white&&n2<4)||(side==black&&n2>3))) s+=CONNECTEDPP;
  161.         }
  162.     }
  163. blocker=board.friends[side]|board.friends[xside];
  164. if(side==white&&(((c&d2e2[white])>>8)&blocker)) s+=BLOCKDEPAWN;
  165. if(side==black&&(((c&d2e2[black])<<8)&blocker)) s+=BLOCKDEPAWN;
  166. if(passed[side]&&board.pmaterial[xside]==0)
  167.     {
  168.     e=board.b[xside];
  169.     i1=board.king[xside];
  170.     p=passed[side];
  171.     while(p)
  172.         {
  173.         sq=leadz(p);
  174.         CLEARBIT(p,sq);
  175.         if(board.side==side)
  176.             {
  177.             if(!(SquarePawnMask[side][sq]&board.b[xside][king])) s+=ValueQ*Passed[side][RANK(sq)]/PFACTOR;
  178.             }
  179.         else if(!(MoveArray[king][i1]&SquarePawnMask[side][sq])) s+=ValueQ*Passed[side][RANK(sq)]/PFACTOR;
  180.         }
  181.     }
  182. c=board.b[side][pawn];
  183. if(abs(ROW(board.king[side])-ROW(board.king[xside]))>=4&&PHASE<6)
  184.     {
  185.     n1=ROW(board.king[xside]);
  186.     p=(IsolaniMask[n1]|FileBit[n1])&c;
  187.     while(p)
  188.         {
  189.         sq=leadz(p);
  190.         CLEARBIT(p,sq);
  191.         s+=10*(5-distance[sq][board.king[xside]]);
  192.         }
  193.     }
  194. return s;
  195. }
  196.  
  197. static const short Outpost[2][64]=
  198. {
  199. {
  200. 0,0,0,0,0,0,0,0,
  201. 0,0,0,0,0,0,0,0,
  202. 0,0,0,0,0,0,0,0,
  203. 0,0,1,1,1,1,0,0,
  204. 0,1,1,1,1,1,1,0,
  205. 0,0,1,1,1,1,0,0,
  206. 0,0,0,1,1,0,0,0,
  207. 0,0,0,0,0,0,0,0 },
  208. { 0,0,0,0,0,0,0,0,
  209. 0,0,0,1,1,0,0,0,
  210. 0,0,1,1,1,1,0,0,
  211. 0,1,1,1,1,1,1,0,
  212. 0,0,1,1,1,1,0,0,
  213. 0,0,0,0,0,0,0,0,
  214. 0,0,0,0,0,0,0,0,
  215. 0,0,0,0,0,0,0,0 }
  216. };
  217.  
  218.  
  219. #ifdef __STORM__
  220. __inline int CTL(short sq,short piece,short side)
  221. #else
  222. static inline int CTL(short sq,short piece,short side)
  223. #endif
  224. {
  225. short s,n,EnemyKing,FriendlyKing;
  226. BitBoard controlled;
  227. s=0;
  228. EnemyKing=board.king[1^side];
  229. FriendlyKing=board.king[side];
  230. controlled=AttackXFrom(sq,side);
  231. n=nbits(controlled&(rings[0]|rings[1]));
  232. s+=4*n;
  233. n=nbits(controlled&DistMap[EnemyKing][2]);
  234. s+=n;
  235. n=nbits(controlled&DistMap[FriendlyKing][2]);
  236. s+=n;
  237. n=nbits(controlled);
  238. s+=4*n;
  239. return s;
  240. }
  241.  
  242. int ScoreN(short side)
  243. {
  244. short s,s1,sq,xside;
  245. short EnemyKing;
  246. BitBoard c,t;
  247. if(board.b[side][knight]==NULLBITBOARD) return 0;
  248. xside=side^1;
  249. s=s1=0;
  250. c=board.b[side][knight];
  251. t=board.b[xside][pawn]; 
  252. EnemyKing=board.king[xside];
  253. while(c)
  254.     {
  255.     sq=leadz(c);
  256.     CLEARBIT(c,sq);
  257.     s1=CTL(sq,knight,side);
  258.     if((BitPosArray[sq] &(FileBit[0]|FileBit[7]|RankBit[0]|RankBit[7]))!=NULLBITBOARD) s1+=KNIGHTONRIM;
  259.     if(Outpost[side][sq]&&!(t&IsolaniMask[ROW(sq)]&PassedPawnMask[side][sq]))
  260.         {
  261.         s1+=OUTPOSTKNIGHT;
  262.         if(MoveArray[ptype[xside]][sq]&board.b[side][pawn]) s1+=OUTPOSTKNIGHT;
  263.         }
  264.     if(MoveArray[knight][sq]&weaked[xside]) s1+=ATAKWEAKPAWN;
  265.     pscore[sq]=s1;
  266.     s+=s1;
  267.     }
  268. return s;
  269. }
  270.  
  271. int ScoreB(short side)
  272. {
  273. short s,s1,xside,n,sq,EnemyKing;
  274. BitBoard c,t;
  275. if(board.b[side][bishop]==NULLBITBOARD) return 0;
  276. s=s1=0;
  277. c=board.b[side][bishop];
  278. xside=side^1;
  279. EnemyKing=board.king[xside];
  280. n=0;
  281. t=board.b[xside][pawn];
  282. while(c)
  283.     {
  284.     sq=leadz(c);
  285.     CLEARBIT(c,sq);
  286.     n++;
  287.     s1=CTL(sq,bishop,side);
  288.     if(Outpost[side][sq]&&!(t&IsolaniMask[ROW(sq)]&PassedPawnMask[side][sq]))
  289.         {
  290.         s1+=OUTPOSTBISHOP;
  291.         if(MoveArray[ptype[xside]][sq]&board.b[side][pawn]) s1+=OUTPOSTBISHOP;
  292.         }
  293.     if(side==white)
  294.         {
  295.         if(board.king[side]>=F1&&board.king[side]<=H1&&sq==G2) s1+=FIANCHETTO;
  296.         if(board.king[side]>=A1&&board.king[side]<=C1&&sq==B2) s1+=FIANCHETTO;
  297.         }
  298.     else if(side==black)
  299.         {
  300.         if(board.king[side]>=F8&&board.king[side]<=H8&&sq==G7) s1+=FIANCHETTO;
  301.         if(board.king[side]>=A8&&board.king[side]<=C8&&sq==B7) s1+=FIANCHETTO;
  302.         }
  303.     if(BishopAttack(sq)&weaked[xside]) s1+=ATAKWEAKPAWN;
  304.     pscore[sq]=s1;
  305.     s+=s1;
  306.     }
  307. if(n>1) s+=DOUBLEDBISHOPS;
  308. return s;
  309. }
  310.  
  311. int BishopTrapped(short side)
  312. {
  313. int s=0;
  314. if(side==white)
  315.     {
  316.     if((board.b[white][bishop]&BitPosArray[A7])&&(board.b[black][pawn]&BitPosArray[B6])&&SwapOff(MOVE(A7,B6))<0) s+=BISHOPTRAPPED;
  317.     if((board.b[white][bishop]&BitPosArray[H7])&&(board.b[black][pawn]&BitPosArray[G6])&&SwapOff(MOVE(H7,G6))<0) s+=BISHOPTRAPPED;
  318.     }
  319. else
  320.     {
  321.     if((board.b[black][bishop]&BitPosArray[A2])&&(board.b[white][pawn]&BitPosArray[B3])&&SwapOff(MOVE(A2,B3))<0) s+=BISHOPTRAPPED;
  322.     if((board.b[black][bishop]&BitPosArray[H2])&&(board.b[white][pawn]&BitPosArray[G3])&&SwapOff(MOVE(H2,G3))<0) s+=BISHOPTRAPPED;
  323.     }
  324. return s;
  325. }
  326.  
  327. int ScoreR(short side)
  328. {
  329. short s,s1,sq,xside,fyle,EnemyKing;
  330. BitBoard c;
  331. if(board.b[side][rook]==NULLBITBOARD) return 0;
  332. s=s1=0;
  333. c=board.b[side][rook];
  334. xside=side^1;
  335. EnemyKing=board.king[xside];
  336. while(c)
  337.     {
  338.     sq=leadz(c);
  339.     CLEARBIT(c,sq);
  340.     s1=CTL(sq,rook,side);
  341.     fyle=ROW(sq);
  342.     if(PHASE<7)
  343.         {
  344.         if(!(board.b[side][pawn]&FileBit[fyle]))
  345.             {
  346.             if(fyle==5&&ROW(board.king[xside])>=E_FILE) s1+=ROOKLIBERATED;
  347.             s1+=ROOKHALFFILE;
  348.             if(!(board.b[xside][pawn]&FileBit[fyle])) s1+=ROOKOPENFILE;
  349.             }
  350.         }
  351.     if(phase>6&&(FileBit[fyle]&passed[white]&brank58[white]))
  352.         {
  353.         if(nbits(Ray[sq][7]&passed[white])==1) s1+=ROOKBEHINDPP;
  354.         else if(Ray[sq][4]&passed[white]) s1+=ROOKINFRONTPP;
  355.         }
  356.     if(FileBit[fyle]&passed[black]&brank58[black])
  357.         {
  358.         if(nbits(Ray[sq][4]&passed[black])==1) s1+=ROOKBEHINDPP;
  359.         else if(Ray[sq][7]&passed[black]) s1+=ROOKINFRONTPP;
  360.         }
  361.     if(RookAttack(sq)&weaked[xside]) s1+=ATAKWEAKPAWN;
  362.     if(RANK(sq)==rank7[side]&&(RANK(EnemyKing)==rank8[side]||board.b[xside][pawn]&RankBit[RANK(sq)])) s1+=ROOK7RANK;
  363.     pscore[sq]=s1;
  364.     s+=s1;
  365.     }
  366. return s;
  367. }
  368.  
  369. int DoubleQR7(short side)
  370. {
  371. short xside;
  372. xside=1^side;
  373. if(nbits((board.b[side][queen]|board.b[side][rook])&brank7[side])>1&&((board.b[xside][king]&brank8[side])||(board.b[xside][pawn]&brank7[side]))) return ROOKS7RANK;
  374. return 0;
  375. }
  376.  
  377. int ScoreQ(short side)
  378. {
  379. short s,s1,sq,xside,EnemyKing;
  380. BitBoard c;
  381. if(board.b[side][queen]==NULLBITBOARD) return 0;
  382. s=s1=0;
  383. xside=1^side;
  384. c=board.b[side][queen];
  385. EnemyKing=board.king[xside];
  386. if(side==computer) if(c==NULLBITBOARD) s+=QUEEN_NOT_PRESENT;
  387. while(c)
  388.     {
  389.     sq=leadz(c);
  390.     CLEARBIT(c,sq);
  391.     s1=CTL(sq,queen,side);
  392.     if(distance[sq][EnemyKing]<=2) s1+=QUEENNEARKING;
  393.     if(QueenAttack(sq)&weaked[xside]) s1+=ATAKWEAKPAWN;
  394.     pscore[sq]=s1;
  395.     s+=s1;
  396.     }
  397. return s;
  398. }
  399.  
  400. static const short KingSq[64]=
  401. {
  402. 24,24,24,16,16,0,32,32,
  403. 24,20,16,12,12,16,20,24,
  404. 16,12,8,4,4,8,12,16,
  405. 12,8,4,0,0,4,8,12,
  406. 12,8,4,0,0,4,8,12,
  407. 16,12,8,4,4,8,12,16,
  408. 24,20,16,12,12,16,20,24,
  409. 24,24,24,16,16,0,32,32
  410. };
  411.  
  412. static const short EndingKing[64]=
  413. {
  414. 0,6,12,18,18,12,6,0,
  415. 6,12,18,24,24,18,12,6,
  416. 12,18,24,32,32,24,18,12,
  417. 18,24,32,48,48,32,24,18,
  418. 18,24,32,48,48,32,24,18,
  419. 12,18,24,32,32,24,18,12,
  420. 6,12,18,24,24,18,12,6,
  421. 0,6,12,18,18,12,6,0
  422. };
  423.  
  424. static short pawncover[9]={-60,-30,0,5,30,30,30,30,30};
  425. static const short factor[9]={7,8,8,7,6,5,4,2,0};
  426. static const BitBoard Corner[2]={ 0xC3C3000000000000ULL,0x000000000000C3C3ULL};
  427.  
  428. int ScoreK(short side)
  429. {
  430. short s,sq,sq1,n,n1,n2,xside,file,fsq,rank;
  431. BitBoard b,x;
  432. s=0;
  433. xside=1^side;
  434. sq=board.king[side];
  435. file=ROW(sq);
  436. rank=RANK(sq);
  437. KingSafety[side]=0;
  438. if(!ENDING)
  439.     { 
  440.     s+=((6-phase)*KingSq[sq]+phase*EndingKing[sq])/6;
  441.     if(side==white) n=nbits(MoveArray[king][sq]&board.b[side][pawn]&RankBit[rank+1]);
  442.     else n=nbits(MoveArray[king][sq]&board.b[side][pawn]&RankBit[rank-1]);
  443.     s+=pawncover[n];
  444.     if(!board.castled[side])
  445.         {
  446.         n=-1;
  447.         if(side==white)
  448.             {
  449.             if(sq==4&&Mvboard[sq]==0)
  450.                 {
  451.                 if((board.b[side][rook]&BitPosArray[H1])!=NULLBITBOARD&&Mvboard[H1]==0) n=nbits(MoveArray[king][G1]&board.b[side][pawn]&RankBit[rank+1]);
  452.                 if((board.b[side][rook]&BitPosArray[A1])!=NULLBITBOARD&&Mvboard[A1]==0) n=nbits(MoveArray[king][C1]&board.b[side][pawn]&RankBit[rank+1]);
  453.                 }
  454.             }
  455.         else
  456.             {
  457.             if(sq==60&&Mvboard[sq]==0)
  458.                 {
  459.                 if((board.b[side][rook]&BitPosArray[H8])!=NULLBITBOARD&&Mvboard[H8]==0)
  460.                 n=nbits(MoveArray[king][G8]&board.b[side][pawn]&RankBit[rank-1]);
  461.                 if((board.b[side][rook]&BitPosArray[A8])!=NULLBITBOARD&&Mvboard[A8]==0)
  462.                 n=nbits(MoveArray[king][C8]&board.b[side][pawn]&RankBit[rank-1]);
  463.                 }
  464.             }
  465.         pawncover[3]=30;
  466.         if(n!=-1) s+=pawncover[n];
  467.         }
  468.     if(side==computer&&file>=F_FILE&&!(FileBit[G_FILE]&board.b[side][pawn]))
  469.         {
  470.         if(side==white&&cboard[F2]==pawn) s+=GOPEN;
  471.         else if(side==black&&cboard[F7]==pawn) s+=GOPEN;
  472.         }
  473.     if(!(FileBit[file]&board.b[side][pawn])) s+=KINGOPENFILE;
  474.     if(!(FileBit[file]&board.b[xside][pawn])) s+=KINGOPENFILE1;
  475.     switch(file)
  476.         {
  477.         case A_FILE:
  478.         case E_FILE:
  479.         case F_FILE:
  480.         case G_FILE:
  481.             if(!(FileBit[file+1]&board.b[side][pawn])) s+=KINGOPENFILE;
  482.             if(!(FileBit[file+1]&board.b[xside][pawn])) s+=KINGOPENFILE1;
  483.             break;
  484.         case H_FILE:
  485.         case D_FILE:
  486.         case C_FILE:
  487.         case B_FILE:
  488.             if(!(FileBit[file-1]&board.b[side][pawn])) s+=KINGOPENFILE;
  489.             if(!(FileBit[file-1]&board.b[xside][pawn])) s+=KINGOPENFILE1;
  490.         }
  491.     if(board.castled[side])
  492.         {
  493.         if(side==white)
  494.             {
  495.             if(file>E_FILE)
  496.                 {
  497.                 if(!(BitPosArray[F2]&board.b[side][pawn])||!(BitPosArray[G2]&board.b[side][pawn])||!(BitPosArray[H2]&board.b[side][pawn])) s+=RUPTURE;
  498.                 }
  499.             else if(file<E_FILE)
  500.                 {
  501.                 if(!(BitPosArray[A2]&board.b[side][pawn])||!(BitPosArray[B2]&board.b[side][pawn])||!(BitPosArray[C2]&board.b[side][pawn])) s+=RUPTURE;
  502.                 }
  503.             }
  504.         else
  505.             {
  506.             if(file>E_FILE)
  507.                 {
  508.                 if(!(BitPosArray[F7]&board.b[side][pawn])||!(BitPosArray[G7]&board.b[side][pawn])||!(BitPosArray[H7]&board.b[side][pawn])) s+=RUPTURE;
  509.                 }
  510.             else if(file<E_FILE)
  511.                 {
  512.                 if(!(BitPosArray[A7]&board.b[side][pawn])||!(BitPosArray[B7]&board.b[side][pawn])||!(BitPosArray[C7]&board.b[side][pawn])) s+=RUPTURE;
  513.                 }
  514.             }
  515.         }
  516.     if(side==computer)
  517.         {
  518.         if(file>=E_FILE&&board.b[xside][queen]&&board.b[xside][rook]&&!((board.b[side][pawn]|board.b[xside][pawn])&FileBit[7])) s+=HOPEN;
  519.         if(side==white)
  520.             {
  521.             if(file>E_FILE)
  522.                 {
  523.                 if(board.b[side][rook]&mask_kr_trapped_w[H_FILE-file]) s+=ROOKTRAPPED;
  524.                 }
  525.             else if(file<D_FILE)
  526.                 {
  527.                 if(board.b[side][rook]&mask_qr_trapped_w[file]) s+=ROOKTRAPPED;
  528.                 }
  529.             }
  530.         else
  531.             {
  532.             if(file>E_FILE)
  533.                 {
  534.                 if(board.b[side][rook]&mask_kr_trapped_b[H_FILE-file]) s+=ROOKTRAPPED;
  535.                 }
  536.             else if(file<D_FILE)
  537.                 {
  538.                 if(board.b[side][rook]&mask_qr_trapped_b[file]) s+=ROOKTRAPPED;
  539.                 }
  540.             }
  541.         }
  542.     if(file>E_FILE&&ROW(board.king[xside])<D_FILE)
  543.         {
  544.         if(side==white)
  545.         fsq=G3; else fsq=G6;
  546.         if((BitPosArray[fsq]&board.b[side][pawn])!=NULLBITBOARD) if(((BitPosArray[F4]|BitPosArray[H4]|BitPosArray[F5]|BitPosArray[H5])&board.b[xside][pawn])!=NULLBITBOARD)  s+=FIANCHETTO_TARGET;    
  547.         }
  548.     if(file<E_FILE&&ROW(board.king[xside])>E_FILE)
  549.         {
  550.         if(side==white) fsq=B3;
  551.         else fsq=B6;
  552.         if((BitPosArray[fsq]&board.b[side][pawn])!=NULLBITBOARD) if(((BitPosArray[A4]|BitPosArray[C4]|BitPosArray[A5]|BitPosArray[C5])&board.b[xside][pawn])!=NULLBITBOARD) s+=FIANCHETTO_TARGET;    
  553.         }
  554.     x=boardhalf[side]&boardside[file<=D_FILE];
  555.     n1=nbits(x&(board.friends[xside]));
  556.     if(n1>0)
  557.         {
  558.         n2=nbits(x &(board.friends[side]&~board.b[side][pawn]&~board.b[side][king]));
  559.         if(n1>n2) s+=(n1-n2)*KING_DEFENDER_DEFICIT;
  560.         }
  561.     KingSafety[side]=s;
  562.     s=(s*factor[phase])/8;
  563.     }
  564. else
  565.     {
  566.     s+=EndingKing[sq];
  567.     s+=CTL(sq,king,side);
  568.     b=(board.b[white][pawn]|board.b[black][pawn]);
  569.     while(b)
  570.         {
  571.         sq1=leadz(b);
  572.         CLEARBIT(b,sq1);
  573.         if(BitPosArray[sq1]&board.b[white][pawn]) s-=distance[sq][sq1+8]*10-5;
  574.         else if(BitPosArray[sq1]&board.b[white][pawn]) s-=distance[sq][sq1-8]*10-5;
  575.         else s-=distance[sq][sq1]-5;
  576.         }
  577.     if(MoveArray[king][sq]&weaked[xside]) s+=ATAKWEAKPAWN*2;
  578.     }
  579. if(phase>=4)
  580.     {
  581.     if(side==white)
  582.         {
  583.         if(sq<A2) if(!(MoveArray[king][sq] &(~board.b[side][pawn]&RankBit[1]))) s+=KING_BACK_RANK_WEAK;
  584.         }
  585.     else
  586.         {
  587.         if(sq>H7) if(!(MoveArray[king][sq] &(~board.b[side][pawn]&RankBit[6]))) s+=KING_BACK_RANK_WEAK;
  588.         }
  589.     }
  590. pscore[sq]=s;
  591. return s;
  592. }
  593.  
  594. int LoneKing(short side,short loser)
  595. {
  596. short s,winer,sq1,sq2;
  597. winer=1^loser;
  598. if(board.material[winer]==ValueB+ValueN&&nbits(board.b[winer][bishop])==1&&nbits(board.b[winer][knight])==1) return(ScoreKBNK(side,loser));
  599. sq1=board.king[winer];
  600. sq2=board.king[loser];
  601. s=150-6*taxicab[sq1][sq2]-EndingKing[sq2];
  602. if(side==loser) s=-s;
  603. s+=MATERIAL;
  604. return s;
  605. }
  606.  
  607. int KPK(short side)
  608. {
  609. short winer,loser,sq,sqw,sql;
  610. int s;
  611. winer=(board.b[white][pawn]?white:black);
  612. loser=1^winer;
  613. sq =leadz(board.b[winer][pawn]);
  614. sqw=board.king[winer];
  615. sql=board.king[loser];
  616. s=ValueP+(ValueQ*Passed[winer][RANK(sq)]/PFACTOR)+4*(winer==white?RANK(sqw):7-RANK(sqw));
  617. if(~SquarePawnMask[winer][sq]&board.b[loser][king])
  618.     {
  619.     if(!(MoveArray[king][sql]&SquarePawnMask[winer][sq])) return(winer==side?s:-s);
  620.     if(winer==side) return s;
  621.     }
  622. if(ROW(sq)!=0&&ROW(sq)!=7&&((IsolaniMask[ROW(sq)]|FileBit[ROW(sq)])&board.b[winer][king]))
  623.     {
  624.     if(winer==white)
  625.         {
  626.         if(RANK(sqw)==RANK(sq)+2) return winer==side?s:-s;
  627.         if(RANK(sqw)==RANK(sq)+1)
  628.             {
  629.             if(RANK(sqw)==5) return winer==side?s:-s;
  630.             if(sqw<A6) 
  631.                 {
  632.                 if(sqw+16==sql&&winer==side) return 0;
  633.                 else return winer==side?s:-s;
  634.                 }
  635.             }
  636.         if(RANK(sqw)==RANK(sq))
  637.             {
  638.             if((RANK(sql)-RANK(sq)<2||RANK(sql)-RANK(sq)>4)&&winer==side) return s;
  639.             if((RANK(sql)-RANK(sq)<1||RANK(sql)-RANK(sq)>5)&&loser==side) return -s;
  640.             if(RANK(sq)==5&&sqw+16!=sql) return winer==side?s:0;
  641.             }
  642.         if(RANK(sq)==6&&RANK(sqw)==5)
  643.             {
  644.             if(sql!=sq+8) return winer==side?s:0;
  645.             if(sql==sq+8&&sql==sqw+16) return winer==side?s:0;
  646.             }
  647.         }
  648.     else
  649.         {
  650.         if(RANK(sqw)==RANK(sq)-2) return winer==side?s:-s;
  651.         if(RANK(sqw)==RANK(sq)-1)
  652.             {
  653.             if(RANK(sqw)==2) return winer==side?s:-s;
  654.             if(sqw>H3)
  655.                 {
  656.                 if(sqw-16==sql&&winer==side) return 0;
  657.                 else return winer==side?s:-s;
  658.                 }
  659.             }
  660.         if(RANK(sqw)==RANK(sq))
  661.             {
  662.             if((RANK(sq)-RANK(sql)<2||RANK(sq)-RANK(sql)>4)&&winer==side) return s;
  663.             if((RANK(sq)-RANK(sql)<1||RANK(sq)-RANK(sql)>5)&&loser==side) return -s;
  664.             if(RANK(sq)==5&&sqw+16!=sql) return winer==side?s:0;
  665.             }
  666.         if(RANK(sq)==1&&RANK(sqw)==2)
  667.             {
  668.             if(sql!=sq-8) return winer==side?s:0;
  669.             if(sql==sq-8&&sql==sqw-16) return winer==side?s:0;
  670.             }
  671.         } 
  672.     }  
  673. return 0;
  674. }
  675.  
  676. short KBNK[64]=
  677. {
  678. 0,10,20,30,40,50,60,70,
  679. 10,20,30,40,50,60,70,60,
  680. 20,30,40,50,60,70,60,50,
  681. 30,40,50,60,70,60,50,40,
  682. 40,50,60,70,60,50,40,30,
  683. 50,60,70,60,50,40,30,20,
  684. 60,70,60,50,40,30,20,10,
  685. 70,60,50,40,30,20,10,0
  686. };
  687.  
  688. int ScoreKBNK(short side,short loser)
  689. {
  690. short s,winer,sq1,sq2,sqB;
  691. winer=1^loser;
  692. sqB=board.king[loser];
  693. if(board.b[winer][bishop]&WHITESQUARES)
  694. sqB=RANK(sqB)*8+7-ROW(sqB);
  695. sq1=board.king[winer];
  696. sq2=board.king[loser];
  697. s=300-6*taxicab[sq1][sq2];
  698. s-=KBNK[sqB];
  699. s-=EndingKing[sq2];
  700. s-=taxicab[leadz(board.b[winer][knight])][sq2];
  701. s-=taxicab[leadz(board.b[winer][bishop])][sq2];
  702. if(board.b[winer][king]&0x00003C3C3C3C0000ULL) s+=20;
  703. if(side==loser) s=-s;
  704. s+=MATERIAL;
  705. return s; 
  706. }
  707.  
  708. static const BitBoard nn[2]={0x4200000000000000ULL,0x0000000000000042ULL};
  709. static const BitBoard bb[2]={0x2400000000000000ULL,0x0000000000000024ULL};
  710. static const BitBoard rr[2]={0x8100000000000000ULL,0x0000000000000081ULL};
  711. static const BitBoard corner=0xC3C300000000C3C3ULL;
  712.  
  713. int ScoreDev(short side)
  714. {
  715. int s=0;
  716. short sq,xside;
  717. BitBoard c;
  718. xside=1^side;
  719. c=(board.b[side][knight]&nn[side])|(board.b[side][bishop]&bb[side]);
  720. s+=nbits(c)*(-8);
  721. if(board.castled[side]||GameCnt/2+1>=20) return s;
  722. s+=NOTCASTLED;
  723. if(Mvboard[board.king[side]]>0) s+=KINGMOVED;
  724. c=board.b[side][rook];
  725. while(c)
  726.     {
  727.     sq=leadz(c);
  728.     CLEARBIT(c,sq);
  729.     if(Mvboard[sq]>0) s+=ROOKMOVED;
  730.     }
  731. if(board.b[side][queen])
  732.     {
  733.     sq=leadz(board.b[side][queen]);
  734.     if(Mvboard[sq]>0) s+=EARLYQUEENMOVE;
  735.     }
  736. c=board.b[side][knight]|board.b[side][bishop];
  737. while(c)
  738.     {
  739.     sq=leadz(c);
  740.     CLEARBIT(c,sq);
  741.     if(Mvboard[sq]>1)    s+=EARLYMINORREPEAT;
  742.     }
  743. c=board.b[side][pawn]&(FileBit[0]|FileBit[1]|FileBit[6]|FileBit[7]);
  744. while(c)
  745.     {
  746.     sq=leadz(c);
  747.     CLEARBIT(c,sq);
  748.     if(Mvboard[sq]>0) s+=EARLYWINGPAWNMOVE;
  749.     }
  750. c=board.b[side][pawn]&(FileBit[2]|FileBit[3]|FileBit[4]|FileBit[5]);
  751. while(c)
  752.     {
  753.     sq=leadz(c);
  754.     CLEARBIT(c,sq);
  755.     if(Mvboard[sq]>1) s+=EARLYCENTERPREPEAT;
  756.     }
  757. return s;
  758. }
  759.  
  760. int Evaluate(int alpha,int beta)
  761. {
  762. short side,xside,s,s1,score;
  763. short npiece[2];
  764. BitBoard *b;
  765. side=board.side;
  766. xside=1^side;
  767. if(alpha>MATE-255||beta<-MATE+255) return MATERIAL; 
  768. if(board.material[white]+board.material[black]==ValueP) return KPK(side);  
  769. if(board.material[xside]==0&&board.b[side][pawn]==NULLBITBOARD) return LoneKing(side,xside);
  770. if(board.material[side]==0&&board.b[xside][pawn]==NULLBITBOARD) return LoneKing(side,side);
  771. EvalCall++;
  772. phase=PHASE;
  773. b=board.b[white];
  774. pieces[white]=b[knight]|b[bishop]|b[rook]|b[queen];
  775. npiece[white]=nbits(pieces[white]);
  776. b=board.b[black];
  777. pieces[black]=b[knight]|b[bishop]|b[rook]|b[queen];
  778. npiece[black]=nbits(pieces[black]);
  779. hunged[white]=hunged[black]=0;
  780. memset(pscore,0,sizeof(pscore));
  781. s1=MATERIAL;
  782. if((s1+maxposnscore[side]<alpha||s1-maxposnscore[xside]>beta)&&phase<=6)
  783.     {
  784.     score=s1;
  785.     goto next;
  786.     }
  787. s=0;
  788. s+=ScoreDev(side)-ScoreDev(xside);
  789. s+=ScoreP(side)-ScoreP(xside);
  790. s+=ScoreK(side)-ScoreK(xside);
  791. s+=BishopTrapped(side)-BishopTrapped(xside);
  792. s+=DoubleQR7(side)-DoubleQR7(xside);
  793. s1=s+MATERIAL;
  794. if(s1+lazyscore[side]<alpha||s1-lazyscore[side]>beta) score=s1;
  795. else
  796.     {
  797.     EvalCnt++;
  798.     s1=0;
  799.     s1+=ScoreN(side)-ScoreN(xside);
  800.     s1+=ScoreB(side)-ScoreB(xside);
  801.     s1+=ScoreR(side)-ScoreR(xside);
  802.     s1+=ScoreQ(side)-ScoreQ(xside);
  803.     lazyscore[side]=MAX(s1,lazyscore[side]);
  804.     maxposnscore[side]=MAX(maxposnscore[side],s+s1);
  805.     score=s+s1+MATERIAL;
  806.     }
  807.  
  808. next:
  809. if(MATERIAL>=200)
  810.     {
  811.     score+=(RootPieces-nbits(pieces[white]|pieces[black]))*TRADEPIECE;
  812.     score-=(RootPawns-nbits(board.b[white][pawn]|board.b[black][pawn]))*TRADEPAWNS;
  813.     }
  814. else if(MATERIAL<=-200)
  815.     {
  816.     score-=(RootPieces-nbits(pieces[white]|pieces[black]))*TRADEPIECE;
  817.     score+=(RootPawns-nbits(board.b[white][pawn]|board.b[black][pawn]))*TRADEPAWNS;
  818.     }
  819. if(ENDING&&pieces[white]==board.b[white][bishop]&&pieces[black]==board.b[black][bishop]&&((pieces[white]&WHITESQUARES&&pieces[black]&BLACKSQUARES)||(pieces[white]&BLACKSQUARES&&pieces[black]&WHITESQUARES))) score/=2;
  820. if(score>0&&!board.b[side][pawn]&&(board.material[side]<ValueR||pieces[side]==board.b[side][knight])) score=0;
  821. if(score<0&&!board.b[xside][pawn]&&(board.material[xside]<ValueR||pieces[xside]==board.b[xside][knight])) score=0;
  822. return score;
  823. }
  824.  
  825. short EvaluateDraw()
  826. {
  827. BitBoard *w,*b;
  828. short wm,bm,wn,bn;
  829. w=board.b[white];
  830. b=board.b[black];
  831. if(w[pawn]!=0||b[pawn]!=0) return false;
  832. wm=board.material[white];
  833. bm=board.material[black];
  834. wn=nbits(w[knight]);
  835. bn=nbits(b[knight]);
  836. if((wm<ValueR ||(wm==2*ValueN&&wn==2))&&(bm<ValueR ||(bm==2*ValueN&&bn==2))) return true;
  837. if(wm<ValueR)
  838.     {
  839.     if(bm==2*ValueB&&(nbits(board.b[black][bishop]&WHITESQUARES)==2||nbits(board.b[black][bishop]&BLACKSQUARES)==2)) return true;
  840.     }
  841. if(bm<ValueR)
  842.     {
  843.     if(wm==2*ValueB&&(nbits(board.b[white][bishop]&WHITESQUARES)==2||nbits(board.b[white][bishop]&BLACKSQUARES)==2)) return true;
  844.     }
  845. return false;
  846. }
  847.